}
struct rte* rte = &(wprdata.rte[idx]);
- route_head* RT = route_head_alloc();
+ auto* RT = new route_head;
RT->rte_num = i;
for (j=RTE_NAME_LEN-1; j >= 0 && rte->name[j] == ' '; j--) {}
char *s = xstrndup(rte->name,j+1);
if (trkhdr->occupied == TRK_UNUSED) {
continue;
}
- route_head* TL = route_head_alloc();
+ auto* TL = new route_head;
for (j=TRK_NAME_LEN-1;
j >= 0 && (trkhdr->name[j] == ' ' || trkhdr->name[j] == '\0');
j--) {}
an1_line_record* rec = Alloc_AN1_Line();
Read_AN1_Line(f, rec);
/* create route rec */
- route_head* rte_head = route_head_alloc();
+ auto* rte_head = new route_head;
rte_head->line_color.bbggrr = rec->linecolor;
if (rec->opacity == 0x8200) {
rte_head->line_color.opacity = 128;
{
QString str;
- route_head* route = route_head_alloc();
+ auto* route = new route_head;
str = inifile_readstr(ini, "client", "routename");
if (!str.isNull()) {
void BendFilter::process_route_orig(const route_head* route_orig)
{
- route_head* route_dest = route_head_alloc();
+ auto* route_dest = new route_head;
route_dest->rte_name = route_orig->rte_name;
route_dest->rte_desc = route_orig->rte_desc;
route_dest->fs = fs_chain_copy(route_orig->fs);
printf(MYNAME ": End Time: %s", ctime(&finish));
}
if (remaining) {
- track = route_head_alloc();
+ track = new route_head;
track->rte_name = PRESTRKNAME;
track->rte_desc = "Brauniger-IQ Barograph";
track_add_head(track);
file_in = gbfopen_le(fname, "rb", MYNAME);
gbfread(h, 1, sizeof(h), file_in);
- trk_head = route_head_alloc();
+ trk_head = new route_head;
track_add_head(trk_head);
trk_head->rte_name = lrtrim(h);
}
break;
case 'R':
- route = route_head_alloc();
+ route = new route_head;
route_add_head(route);
parse_rte_info(ctail, route);
break;
wpt = parse_trkpt(ctail);
if (wpt != nullptr) {
if (track == nullptr) {
- track = route_head_alloc();
+ track = new route_head;
track_add_head(track);
}
track_add_wpt(track, wpt);
wpt->urls.clear();
if (temp_route == nullptr) {
- temp_route = route_head_alloc();
+ temp_route = new route_head;
route_add_head(temp_route);
}
route_add_wpt(temp_route, new Waypoint(*wpt));
data_lines++;
if (strcmp(name, "1") == 0) {
- track = route_head_alloc();
+ track = new route_head;
track_add_head(track);
} else if (strncmp(name, "NAME:", 5) == 0) {
wpt->shortname = QString::fromLatin1(name + 5);
{
gpl_point_t gp;
- route_head* track_head = route_head_alloc();
+ auto* track_head = new route_head;
track_add_head(track_head);
while (gbfread(&gp, sizeof(gp), 1, gplfile_in) > 0) {
}
if (! rte) {
- rte = route_head_alloc();
+ rte = new route_head;
route_add_head(rte);
}
route_add_wpt(rte, wpt);
}
if (! trk) {
- trk = route_head_alloc();
+ trk = new route_head;
track_add_head(trk);
}
track_add_wpt(trk, wpt);
strncpy(buf, model->name, sizeof(buf));
strftime(&buf[strlen(model->name)], sizeof(buf)-strlen(model->name), " tracklog (%Y/%m/%d %H:%M:%S)",
gmtime(&creation_time));
- *track = route_head_alloc();
+ *track = new route_head;
(*track)->rte_name = buf;
(*track)->rte_desc = "GPS tracklog data";
track_add_head(*track);
tlog3b_xgcb_tfna(xg_string args, const QXmlStreamAttributes*)
{
if (xmltrk == nullptr) {
- xmltrk = route_head_alloc();
+ xmltrk = new route_head;
track_add_head(xmltrk);
}
xmltrk->rte_name = args;
tlog3b_xgcb_tfdes(xg_string args, const QXmlStreamAttributes*)
{
if (xmltrk == nullptr) {
- xmltrk = route_head_alloc();
+ xmltrk = new route_head;
track_add_head(xmltrk);
}
xmltrk->rte_desc = args;
finalize_pt(xmlwpt);
if (xmltrk == nullptr) {
- xmltrk = route_head_alloc();
+ xmltrk = new route_head;
track_add_head(xmltrk);
}
track_add_wpt(xmltrk, xmlwpt);
(void) gbfgetint32(fin); // Unknown 3
(void) gbfgetint32(fin); // Unknown 4
- route_head* track = route_head_alloc();
+ auto* track = new route_head;
track_add_head(track);
/* S1 .. S9: comments, hints, jokes, aso */
QTime gpsTime = QTime(workout.timeStart.Hour,workout.timeStart.Minute,workout.timeStart.Second);
gpsbabel::DateTime gpsDateTime = gpsbabel::DateTime(gpsDate,gpsTime);
gpsDateTime.setTimeSpec(Qt::UTC);
- route_head* gpsbabel_route = route_head_alloc();
+ auto* gpsbabel_route = new route_head;
track_add_head(gpsbabel_route);
gbfseek(file_in, 0L, SEEK_SET);
data_read()
{
enigma_wpt ewpt;
- route_head* route = route_head_alloc();
+ auto* route = new route_head;
route_add_head(route);
while (1 == gbfread(&ewpt, sizeof(ewpt), 1, file_in)) {
fatal(MYNAME ": bad header");
}
// start the track list
- track = route_head_alloc();
+ track = new route_head;
is_fatal((track == nullptr), MYNAME ": memory non-enough");
track->rte_name = fname;
track_add_head(track);
//
// For routes:
//
-// route = route_head_alloc();
+// route = new route_head;
// populate struct route_hdr
// route_add_head(route);
// while (have more routepoints) {
case 'N': /* track log header */
mode = trkdata;
- head = route_head_alloc();
+ head = new route_head;
cdata = strchr(cdata, '-');
if (cdata) {
while (isspace(*cdata)) {
case 'R': /* route header */
mode = rtedata;
- head = route_head_alloc();
+ head = new route_head;
cdata += 3; /*skip route number */
if (*cdata) {
head->rte_name = cdata;
}
if (trk_head == nullptr || array[i]->ishdr) {
- trk_head = route_head_alloc();
+ trk_head = new route_head;
trk_head->rte_num = trk_num;
trk_head->rte_name = QString::fromLatin1(trk_name);
trk_num++;
default:
break;
}
- rte_head = route_head_alloc();
+ rte_head = new route_head;
route_add_head(rte_head);
if (csrc) {
rte_head->rte_name = QString::fromLatin1(csrc);
) {
static struct tm* stmp;
stmp = gmtime(&array[i]->start_time);
- trk_head = route_head_alloc();
+ trk_head = new route_head;
/*For D906, we would like to use the track_index in the last packet instead...*/
trk_head->rte_num = ++trk_num;
strftime(tbuf, 32, "%Y-%m-%dT%H:%M:%SZ", stmp);
{
fit_parse_header();
- fit_data.track = route_head_alloc();
+ fit_data.track = new route_head;
track_add_head(fit_data.track);
if (global_opts.debug_level >= 1) {
debug_print(1,"%s: starting to read data with fit_data.len=%d\n", MYNAME, fit_data.len);
char* str;
int column = -1;
- route_head* rte = route_head_alloc();
+ auto* rte = new route_head;
bind_fields(route_header);
while ((str = csv_lineparse(nullptr, "\t", "", column++))) {
int column = -1;
bind_fields(track_header);
- route_head* trk = route_head_alloc();
+ auto* trk = new route_head;
while ((str = csv_lineparse(nullptr, "\t", "", column++))) {
int field_no = header_fields[track_header][column];
switch (field_no) {
// Generate Track Header
uint16_t trackbytes = format_garmin_xt_rd_st_attrs(trk_name, &trk_color) - 50; // Bytes in track
- route_head* tmp_track = route_head_alloc();
+ auto* tmp_track = new route_head;
// update track color
tmp_track->line_color.bbggrr = colors[trk_color];
tmp_track->line_color.opacity = 255;
}
if (! track) {
- track = route_head_alloc();
+ track = new route_head;
// header option was not set to ignore
if (method !=1) {
track->rte_name = "ATRK XT";
rte_ct++;
int warnings = 0;
- route_head* rte = route_head_alloc();
+ auto* rte = new route_head;
rte->rte_name = fread_cstr();
FREAD(buf, 1); /* display/autoname - 1 byte */
trk_ct++;
- route_head* res = route_head_alloc();
+ auto* res = new route_head;
res->rte_name = fread_cstr();
// res->rte_num = trk_ct;
for (auto && lineStringIterator : polygon)
{
QJsonArray coordinates = (lineStringIterator).toArray();
- auto route = route_head_alloc();
+ auto* route = new route_head;
route_add_head(route);
for (auto && coordinate : coordinates)
{
else if (geometry_type == LINESTRING)
{
QJsonArray coordinates = geometry.value(COORDINATES).toArray();
- auto route = route_head_alloc();
+ auto* route = new route_head;
route->rte_name = name;
route_add_head(route);
for (auto && coordinate : coordinates)
for (auto && line_string : line_strings)
{
QJsonArray coordinates = line_string.toArray();
- auto route = route_head_alloc();
+ auto* route = new route_head;
track_add_head(route);
for (auto && coordinate : coordinates)
{
ggv_bin_read16(stream, "line width");
ggv_bin_read16(stream, "line type");
line_points = ggv_bin_read16(stream, "line points");
- ggv_bin_track = route_head_alloc();
+ ggv_bin_track = new route_head;
track_add_head(ggv_bin_track);
if (! track_name.isEmpty()) {
ggv_bin_track->rte_name = track_name;
// area
case 0x17:
// line
- ggv_bin_track = route_head_alloc();
+ ggv_bin_track = new route_head;
track_add_head(ggv_bin_track);
if (! label.isEmpty()) {
}
if (trk == nullptr) {
- trk = route_head_alloc();
+ trk = new route_head;
track_add_head(trk);
}
if (points > 0) {
route_head* trk;
- route_head* rte = trk = route_head_alloc();
+ auto* rte = trk = new route_head;
if (group > 1) {
route_add_head(rte);
route_ct++;
}
if (!showlist) {
- route_head* trk = route_head_alloc();
+ auto* trk = new route_head;
trk->rte_name = QString::asprintf("%02d-%02d-%02d_%02d:%02d:%02d",
header.dateStart.Year,
void gl_trk_s(xg_string, const QXmlStreamAttributes*)
{
- trk_head = route_head_alloc();
+ trk_head = new route_head;
track_add_head(trk_head);
}
wpt->altitude = read_altitude(&rec.alt);
if (trk == nullptr) {
- trk = route_head_alloc();
+ trk = new route_head;
track_add_head(trk);
}
track_add_wpt(trk, wpt);
long lon = 0;
const QByteArray qbstr = encoded_points.toUtf8();
- route_head* routehead = route_head_alloc();
+ auto* routehead = new route_head;
if (args == "overview_polyline") {
routehead->rte_name = "overview";
routehead->rte_desc = "Overview";
double lat_old = 0;
- route_head* route = route_head_alloc();
+ auto* route = new route_head;
QDateTime qtx = QDateTime::fromSecsSinceEpoch(tx, Qt::UTC);
route->rte_name = "Tracklog ";
route->rte_name += qtx.toString(Qt::ISODate);
}
break;
case tt_rte:
- rte_head = route_head_alloc();
+ rte_head = new route_head;
route_add_head(rte_head);
rh_link_ = new UrlLink;
fs_ptr = &rte_head->fs;
tag_wpt(attr);
break;
case tt_trk:
- trk_head = route_head_alloc();
+ trk_head = new route_head;
track_add_head(trk_head);
rh_link_ = new UrlLink;
fs_ptr = &trk_head->fs;
wpt->altitude = unknown_alt;
}
if (start_new || !trk_head) {
- trk_head = route_head_alloc();
+ trk_head = new route_head;
track_add_head(trk_head);
real_track_list.append(trk_head);
}
fread_discard(file_in, 2);
if (start_new || !rte_head) {
- rte_head = route_head_alloc();
+ rte_head = new route_head;
rte_head->rte_name = route_name;
route_add_head(rte_head);
}
void
gtc_trk_s(xg_string, const QXmlStreamAttributes*)
{
- trk_head = route_head_alloc();
+ trk_head = new route_head;
track_add_head(trk_head);
}
static
void ht_trk_s(xg_string, const QXmlStreamAttributes*)
{
- trk_head = route_head_alloc();
+ trk_head = new route_head;
track_add_head(trk_head);
}
if ((map.value(buff))) {
const Waypoint* wpt = map.value(buff);
if (rte == nullptr) {
- rte = route_head_alloc();
+ rte = new route_head;
route_add_head(rte);
// TODO: find a way to eliminate the copy.
char* s = xstrndup(hrte.name, sizeof(hrte.name));
int32_t accum_east = th.start_east;
int32_t accum_north = th.start_north;
- route_head* trk = route_head_alloc();
+ auto* trk = new route_head;
track_add_head(trk);
// TODO: find a way to eliminate the copy.
int32_t accum_east = th.start_east;
int32_t accum_north = th.start_north;
- route_head* trk = route_head_alloc();
+ auto* trk = new route_head;
track_add_head(trk);
/* The name is not in the header, but at the end of the file.
creation = mkgmtime(&tm);
// Create a route to store the task data in.
- rte_head = route_head_alloc();
+ rte_head = new route_head;
rte_head->rte_name = task_num;
rte_head->rte_desc = QStringLiteral(DATEMAGIC) + flight_date + QStringLiteral(": ") + task_desc;
route_add_head(rte_head);
}
// Create a track for pressure altitude waypoints
if (!pres_head) {
- pres_head = route_head_alloc();
+ pres_head = new route_head;
pres_head->rte_name = PRESTRKNAME;
pres_head->rte_desc = trk_desc;
track_add_head(pres_head);
}
// Create a second track for GNSS altitude waypoints
if (!gnss_head) {
- gnss_head = route_head_alloc();
+ gnss_head = new route_head;
gnss_head->rte_name = GNSSTRKNAME;
gnss_head->rte_desc = trk_desc;
track_add_head(gnss_head);
{
ignr_xml_error((track != nullptr));
- track = route_head_alloc();
+ track = new route_head;
track_add_head(track);
}
{
igo8_point point;
- route_head* track_head = route_head_alloc();
+ auto* track_head = new route_head;
track_add_head(track_head);
while (in_point_count &&
waypt = new Waypoint;
break;
case 1:
- track = route_head_alloc();
+ track = new route_head;
break;
default:
fatal(MYNAME ": Unknown object type %s!\n", qPrintable(args));
// time is not maintainable. When new members are added it is likely
// they will not be copied here!
// We want a deep copy of everything but with an empty WaypointList.
- route_head* rte_new = route_head_alloc();
+ auto* rte_new = new route_head;
rte_new->rte_name = rte_old->rte_name;
rte_new->rte_desc = rte_old->rte_desc;
rte_new->rte_urls = rte_old->rte_urls;
static void
itracku_read_trk()
{
- itracku_read_trk_track = route_head_alloc();
+ itracku_read_trk_track = new route_head;
track_add_head(itracku_read_trk_track);
itracku_waypt_input(&itracku_read_trk_waypt_add);
}
static void
jogmap_markers(xg_string, const QXmlStreamAttributes*)
{
- trk = route_head_alloc();
+ trk = new route_head;
track_add_head(trk);
}
}
if (trk == nullptr) {
- trk = route_head_alloc();
+ trk = new route_head;
track_add_head(trk);
}
void trk_coord(xg_string args, const QXmlStreamAttributes*)
{
- route_head* trk_head = route_head_alloc();
+ auto* trk_head = new route_head;
if (wpt_tmp && !wpt_tmp->shortname.isEmpty()) {
trk_head->rte_name = wpt_tmp->shortname;
}
void gx_trk_s(xg_string, const QXmlStreamAttributes*)
{
- gx_trk_head = route_head_alloc();
+ gx_trk_head = new route_head;
if (wpt_tmp && !wpt_tmp->shortname.isEmpty()) {
gx_trk_head->rte_name = wpt_tmp->shortname;
}
kml_wr_init(posnfilenametmp);
if (!posn_trk_head) {
- posn_trk_head = route_head_alloc();
+ posn_trk_head = new route_head;
track_add_head(posn_trk_head);
}
}
for (int i = 0; i < num_routes; i++) {
- rte_head = route_head_alloc();
+ rte_head = new route_head;
route_add_head(rte_head);
rte_head->rte_num = i+1;
char continuous = gbfgetc(file_in);
if (!continuous && opt_seg_break && j) {
/* option to break trails into segments was specified */
- auto trk_tmp = route_head_alloc();
+ auto* trk_tmp = new route_head;
trk_tmp->rte_num = ++(*trail_num);
trk_tmp->rte_name = trk_head->rte_name;
track_add_head(trk_tmp);
}
for (int i = trail_num = 0; i < num_trails && !gbfeof(file_in); i++) {
- trk_head = route_head_alloc();
+ trk_head = new route_head;
trk_head->rte_num = ++trail_num;
track_add_head(trk_head);
* from input filename.
*/
- trk_head = route_head_alloc();
+ trk_head = new route_head;
/* Whack trailing extension if present. */
QString s = get_filename(curfname);
*/
if (frag == mag_rte_head->nelems) {
- route_head* rte_head = route_head_alloc();
+ auto* rte_head = new route_head;
route_add_head(rte_head);
rte_head->rte_num = rtenum;
rte_head->rte_name = rte_name;
}
if (! trk) {
- trk = route_head_alloc();
+ trk = new route_head;
track_add_head(trk);
}
track_add_wpt(trk, wpt);
static void
mapbar_track_read()
{
- route_head* track = route_head_alloc();
+ auto* track = new route_head;
is_fatal((track == nullptr), MYNAME ": memory non-enough");
track_add_head(track);
int rte_count = gbfgetint32(mapsend_file_in);
while (rte_count--) {
- route_head* rte_head = route_head_alloc();
+ auto* rte_head = new route_head;
route_add_head(rte_head);
/* route name */
static void
mapsend_track_read()
{
- route_head* track_head = route_head_alloc();
+ auto* track_head = new route_head;
track_head->rte_name = gbfgetpstr(mapsend_file_in);
track_add_head(track_head);
fprintf(stderr, "mps_route_r: route contains %d waypoints\n", rte_count);
#endif
- rte_head = route_head_alloc();
+ rte_head = new route_head;
rte_head->rte_name = rtename;
route_add_head(rte_head);
*rte = rte_head;
fprintf(stderr, "mps_track_r: there are %d track waypoints\n", trk_count);
#endif
- track_head = route_head_alloc();
+ track_head = new route_head;
track_head->rte_name = trkname;
track_add_head(track_head);
*trk = track_head;
DBG((sobj, "name = \"%s\" [ visible=%s, id=0x%04X ]\n",
data->name, data->visible ? "yes" : "NO", data->objid));
- data->data = rte = route_head_alloc();
+ data->data = rte = new route_head;
rte->rte_name = data->name;
route_add_head(rte);
DBG((sobj, "name = \"%s\" [ visible=%s, id=0x%04X ]\n",
data->name, data->visible ? "yes" : "NO", data->objid));
- route_head* trk = route_head_alloc();
+ auto* trk = new route_head;
trk->rte_name = data->name;
track_add_head(trk);
static void
mtk_locus_read()
{
- track = route_head_alloc();
+ track = new route_head;
track_add_head(track);
dbg(1, "Track initialized\n");
if (global_opts.masked_objective& TRKDATAMASK && (trk_head == nullptr || (mtk_info.track_event & MTK_EVT_START))) {
char spds[50];
- trk_head = route_head_alloc();
+ trk_head = new route_head;
trk_head->rte_name = QString("track-%1").arg(1 + track_count());
spds[0] = '\0';
gpsbabel::TextStream stream;
stream.open(read_fname, QIODevice::ReadOnly, "mynav");
- route_head* track = route_head_alloc();
+ auto* track = new route_head;
track_add_head(track);
QString buf;
data_read()
{
if (process_rte) {
- rte_head = route_head_alloc();
+ rte_head = new route_head;
route_add_head(rte_head);
}
unsigned int address = le_read32(information + 4);
unsigned short total = le_read16(information + 12);
- route_head* track = route_head_alloc();
+ auto* track = new route_head;
track_add_head(track);
while (total > 0) {
write_packet(PID_QRY_ROUTE, payload, sizeof(payload));
read_packet(PID_DATA, routedata, 64, sizeof(routedata), false);
- route_head* route = route_head_alloc();
+ auto* route = new route_head;
route->rte_num = routedata[2];
route->rte_name = (char*)routedata + 4;
route_add_head(route);
read_datalog_info(&seg1_addr, &seg1_len, &seg2_addr, &seg2_len);
- route_head* track = route_head_alloc();
+ auto* track = new route_head;
track_add_head(track);
if (seg1_len) {
default:
if (global_opts.masked_objective & TRKDATAMASK) {
if (track == nullptr) {
- track = route_head_alloc();
+ track = new route_head;
track_add_head(track);
}
wpt->longitude = GPS_Math_Semi_To_Deg(lon);
if ((lat >> 31) || (trk == nullptr)) {
- trk = route_head_alloc();
+ trk = new route_head;
track_add_head(trk);
}
track_add_wpt(trk, wpt);
gpgll_parse(char* ibuf)
{
if (trk_head == nullptr) {
- trk_head = route_head_alloc();
+ trk_head = new route_head;
track_add_head(trk_head);
}
gpgga_parse(char* ibuf)
{
if (trk_head == nullptr) {
- trk_head = route_head_alloc();
+ trk_head = new route_head;
track_add_head(trk_head);
}
gprmc_parse(char* ibuf)
{
if (trk_head == nullptr) {
- trk_head = route_head_alloc();
+ trk_head = new route_head;
track_add_head(trk_head);
}
* we can rip through the queue forward now to get our
* handy-dandy reversing effect.
*/
- route_head* trk_head = route_head_alloc();
+ auto* trk_head = new route_head;
track_add_head(trk_head);
while (!pcmpt_head.isEmpty()) {
Waypoint* wpt = pcmpt_head.takeFirst();
QString zip2, city, street, number;
- route_head* route = route_head_alloc();
+ auto* route = new route_head;
route_add_head(route);
while ((buff = gbfgetstr(fin))) {
static void
osm_way(xg_string, const QXmlStreamAttributes* attrv)
{
- rte = route_head_alloc();
+ rte = new route_head;
// create a wpt to represent the route center if it has a center tag
wpt = new Waypoint;
if (attrv->hasAttribute("id")) {
case 2:
/* new track flag */
if ((str.toInt() == 1) && (trk_head->rte_waypt_ct > 0)) {
- trk_head = route_head_alloc();
+ trk_head = new route_head;
track_add_head(trk_head);
if (trk_name) {
trk_head->rte_name = trk_name;
switch (field) {
case 0:
/* R */
- rte_head = route_head_alloc();
+ rte_head = new route_head;
route_add_head(rte_head);
break;
case 1:
*/
if (linecount == 1) {
if (buff.contains("Track Point")) {
- trk_head = route_head_alloc();
+ trk_head = new route_head;
track_add_head(trk_head);
ozi_objective = trkdata;
} else if (buff.contains("Route File")) {
}
if (track == nullptr) {
if (ibuf[3] == 'L' && ibuf[4] == 'A') {
- track = route_head_alloc();
+ track = new route_head;
track->rte_name = "track";
track_add_head(track);
} else if (ibuf[3] == 'T' && ibuf[4] == 'N') {
- track = route_head_alloc();
+ track = new route_head;
track->rte_name = &ibuf[6];
track_add_head(track);
}
}
break;
case 'R':
- route = route_head_alloc();
+ route = new route_head;
route->rte_name = QString(&ibuf[1]).trimmed();
route_add_head(route);
break;
/* Did we get a track point before a track header? */
if (track == nullptr) {
- track = route_head_alloc();
+ track = new route_head;
track->rte_name = "Default";
track_add_head(track);
}
read_tracks()
{
breadcrumb bc;
- route_head* trk_head = route_head_alloc();
+ auto* trk_head = new route_head;
trk_head->rte_num = 1;
trk_head->rte_name = "PocketFMS";
trk_head->rte_desc = "Breadcrumb";
{
if (isFirst == 1) {
wpt_from = new Waypoint;
- route = route_head_alloc();
+ route = new route_head;
route->rte_desc="PocketFMS flightplan";
route_add_head(route);
}
rtrim(rtename);
- route_head* rte_head = route_head_alloc();
+ auto* rte_head = new route_head;
rte_head->rte_name = rtename;
route_add_head(rte_head);
*rte = rte_head;
psit_getToken(psit_file,psit_current_token,sizeof(psit_current_token), whitespace);
if ((strcmp(psit_current_token, "1") == 0) || (track_head == nullptr)) {
- track_head = route_head_alloc();
+ track_head = new route_head;
/* Add a number to the track name. With Garmins, the "first"
tracklog is usually ACTIVE LOG
the second is ACTIVE LOG001 and so on */
}
if (routename) {
- rte_head = route_head_alloc();
+ rte_head = new route_head;
rte_head->rte_name = routename;
route_add_head(rte_head);
}
int points = (opt_points) ? atoi(opt_points) : rand_int(128) + 1;
if (doing_trks || doing_rtes) {
- head = route_head_alloc();
+ head = new route_head;
if (doing_trks) {
head->rte_name = rand_str(8, "Trk_%s");
track_add_head(head);
break;
}
- route_head* rte = route_head_alloc();
+ auto* rte = new route_head;
rte->rte_name = name;
route_add_head(rte);
return global_track_list->count(); /* total # of tracks */
}
-// FIXME: provide a method to deallocate a head that isn't added onto a route list,
-// or just let the users allocate with new and deallocate with delete.
-route_head*
-route_head_alloc()
-{
- return new route_head;
-}
-
void
route_add_head(route_head* rte)
{
const char RPT[] = "RPT";
foreach (const route_head* rte_old, *this) {
- route_head* rte_new = route_head_alloc();
+ auto* rte_new = new route_head;
// waypoint_list created below with add_wpt.
rte_new->rte_name = rte_old->rte_name;
rte_new->rte_desc = rte_old->rte_desc;
* here lie the route description records
*/
if (version < 6 || (control == 1)) {
- track_head = route_head_alloc();
+ track_head = new route_head;
route_add_head(track_head);
if (control) {
track_head->rte_name = "control points";
*/
count = ReadLong(infile);
if (count) {
- track_head = route_head_alloc();
+ track_head = new route_head;
if (timesynth) {
track_add_head(track_head);
} else {
if (split && stringlen) {
if (track_head->rte_waypt_ct) {
old_track_head = track_head;
- track_head = route_head_alloc();
+ track_head = new route_head;
if (timesynth) {
track_add_head(track_head);
} else {
sbn_read()
{
if (global_opts.masked_objective & TRKDATAMASK) {
- route_head* track = route_head_alloc();
+ auto* track = new route_head;
track_add_head(track);
read_sbn_header(track);
{
Waypoint* logpoint;
- route_head* track = route_head_alloc();
+ auto* track = new route_head;
track_add_head(track);
read_sbp_header(track);
// Parts may or may not be connected to one another.
// Parts may or may not intersect one another.
for (int part=0; part < shp->nParts; part++) {
- route_head* routehead = route_head_alloc();
+ auto* routehead = new route_head;
routehead->rte_name = name;
route_add_head(routehead);
int endVertex;
}
if (rte == nullptr) {
- rte = route_head_alloc();
+ rte = new route_head;
route_add_head(rte);
rte->rte_num = rte_num;
}
continue;
}
if (trk == nullptr) {
- trk = route_head_alloc();
+ trk = new route_head;
track_add_head(trk);
}
track_add_wpt(trk, wpt);
static void
state_init(struct read_state* pst)
{
- route_head* track = route_head_alloc();
+ auto* track = new route_head;
track->rte_name = "SkyTraq tracklog";
track->rte_desc = "SkyTraq GPS tracklog data";
track_add_head(track);
if (nullptr == pst->route_head_) {
db(1, MYNAME ": New Track\n");
- pst->route_head_ = route_head_alloc();
+ pst->route_head_ = new route_head;
track_add_head(pst->route_head_);
}
track = nullptr;
}
if (track == nullptr) {
- track = route_head_alloc();
+ track = new route_head;
track_add_head(track);
trackno++;
if (rte_name != nullptr) {
case 2:
case 3:
if (route == nullptr) {
- route = route_head_alloc();
+ route = new route_head;
route_add_head(route);
}
route_add_wpt(route, wpt);
waypt_add(wpt);
if (global_opts.objective == rtedata) {
if (route == nullptr) {
- route = route_head_alloc();
+ route = new route_head;
route_add_head(route);
}
route_add_wpt(route, new Waypoint(*wpt));
case STM_TRKPT:
if (track == nullptr) {
- track = route_head_alloc();
+ track = new route_head;
track_add_head(track);
}
track_add_wpt(track, wpt);
static void
tef_header(xg_string, const QXmlStreamAttributes* attrv)
{
- route = route_head_alloc();
+ route = new route_head;
foreach(QXmlStreamAttribute attr, *attrv) {
if (attr.name().compare(QLatin1String("Name"), Qt::CaseInsensitive) == 0) {
route->rte_name = attr.value().toString().trimmed();
for (int i = 0; i < track_count; i++) {
- route_head* track_temp = route_head_alloc();
+ auto* track_temp = new route_head;
track_add_head(track_temp);
/* generate a generic track name */
char rgb[7],bgr[7];
// Allocate the track struct
- route_head* track_temp = route_head_alloc();
+ auto* track_temp = new route_head;
track_add_head(track_temp);
//UNKNOWN DATA LENGTH
//
for (unsigned int ii = 0; ii < route_count; ii++) {
// Allocate the route struct
- route_head* route_temp = route_head_alloc();
+ auto* route_temp = new route_head;
route_add_head(route_temp);
//UNKNOWN DATA LENGTH
#ifdef TRACKF_DBG
printf(MYNAME ": splitting new track\n");
#endif
- curr = route_head_alloc();
+ curr = new route_head;
trackfilter_split_init_rte_name(curr, buff.at(j)->GetCreationTime());
track_add_head(curr);
track_list.append(curr);
foreach (Waypoint* wpt, src->waypoint_list) {
if (wpt->wpt_flags.new_trkseg && !first) {
- dest = route_head_alloc();
+ dest = new route_head;
dest->rte_num = src->rte_num;
/* name in the form TRACKNAME #n */
if (!src->rte_name.isEmpty()) {
void TransformFilter::transform_waypoints()
{
- route_head* rte = route_head_alloc();
+ auto* rte = new route_head;
switch (current_target) {
case 'R':
route_add_head(rte);
current_namepart = rte->rte_name;
}
if (current_target == 'T') {
- current_trk = route_head_alloc();
+ current_trk = new route_head;
track_add_head(current_trk);
if (!rte->rte_name.isEmpty()) {
current_trk->rte_desc = QString("Generated from route %1").arg(rte->rte_name);
current_namepart = trk->rte_name;
}
if (current_target == 'R') {
- current_rte = route_head_alloc();
+ current_rte = new route_head;
route_add_head(current_rte);
if (!trk->rte_name.isEmpty()) {
current_rte->rte_desc = "Generated from track ";
switch (unicsv_data_type) {
case rtedata:
if (! unicsv_route) {
- unicsv_route = route_head_alloc();
+ unicsv_route = new route_head;
route_add_head(unicsv_route);
}
route_add_wpt(unicsv_route, wpt);
break;
case trkdata:
if (! unicsv_track) {
- unicsv_track = route_head_alloc();
+ unicsv_track = new route_head;
track_add_head(unicsv_track);
}
track_add_wpt(unicsv_track, wpt);
}
return d;
-}
\ No newline at end of file
+}
v900_log("header line: %s",line.text);
v900_log("is_advance_mode=%d\n",is_advanced_mode);
- route_head* track = route_head_alloc();
+ auto* track = new route_head;
track->rte_name = "V900 tracklog";
track->rte_desc = "V900 GPS tracklog data";
track_add_head(track);
}
if (!trk) {
- trk = route_head_alloc();
+ trk = new route_head;
track_add_head(trk);
}
static void
vitosmt_read()
{
- route_head* route_head =nullptr;
+ route_head* rte = nullptr;
struct tm tmStruct;
int serial =0;
if (doing_wpts) { /* process as waypoints */
waypt_add(wpt_tmp);
} else if (doing_rtes) { /* process as route */
- if (route_head == nullptr) {
- route_head = route_head_alloc();
- route_add_head(route_head);
+ if (rte == nullptr) {
+ rte = new route_head;
+ route_add_head(rte);
}
- route_add_wpt(route_head, wpt_tmp);
+ route_add_wpt(rte, wpt_tmp);
} else { /* default track mode */
- if (route_head == nullptr) {
- route_head = route_head_alloc();
- track_add_head(route_head);
+ if (rte == nullptr) {
+ rte = new route_head;
+ track_add_head(rte);
}
- track_add_wpt(route_head, wpt_tmp);
+ track_add_wpt(rte, wpt_tmp);
}
xfree(timestamp);
memset(&tmStruct, 0, sizeof(tmStruct));
- route_head* route_head = route_head_alloc();
- track_add_head(route_head);
+ auto* rte = new route_head;
+ track_add_head(rte);
/* Read the header. */
int version = gbfgetint32(infile);
(void) course;
(void) status;
- track_add_wpt(route_head, wpt_tmp);
+ track_add_wpt(rte, wpt_tmp);
count--;
}
// Set up a track
if (track_head == nullptr) {
- track_head = route_head_alloc();
+ track_head = new route_head;
track_add_head(track_head);
}
if (nullptr == st->route_head_) {
db(1, "New Track\n");
- st->route_head_ = route_head_alloc();
+ st->route_head_ = new route_head;
track_add_head(st->route_head_);
}
if (nullptr == st->route_head_) {
db(1, "New Track\n");
- st->route_head_ = route_head_alloc();
+ st->route_head_ = new route_head;
track_add_head(st->route_head_);
}
static void
wintec_tes_read()
{
- route_head* trk = route_head_alloc();
+ auto* trk = new route_head;
track_add_head(trk);
while (!gbfeof(fin)) {
break;
case trkdata:
if ((trk == nullptr) || parse_data.new_track) {
- trk = route_head_alloc();
+ trk = new route_head;
track_add_head(trk);
}
if (!parse_data.trk_name.isEmpty()) {
break;
case rtedata:
if (rte == nullptr) {
- rte = route_head_alloc();
+ rte = new route_head;
route_add_head(rte);
}
if (!parse_data.rte_name.isEmpty()) {
if (attrv->value("type") == "waypoint") {
wpt = new Waypoint;
} else if (attrv->value("type") == "polyline") {
- trk = route_head_alloc();
+ trk = new route_head;
track_add_head(trk);
}
}